An Overview of Event-based Facades for Modular Composition and Coordination of Multiple Applications

Complex software systems are usually developed as systems of systems (SoS’s) in which multiple constituent applications are composed and coordinated to fulfill desired system-level requirements. The constituent applications must be augmented with suitable coordination-specific interfaces, through which they can participate in coordinated interactions. Such interfaces as well as coordination rules have a crosscutting nature. Therefore, to increase the reusability of the applications and to increase the comprehensibility of SoS’s, suitable mechanisms are required to modularize the coordination rules and interfaces from the constituent applications. We introduce a new abstraction named as architectural event modules (AEMs), which facilitate defining constituent applications and desired coordination rules as modules of SoS’s. AEMs augment the constituent applications with event-based facades to let them participate in coordinated interactions. We introduce the EventArch language in which the concept of AEMs is implemented, and illustrate its suitability using a case study

A Rule Set to Detect Interference of Runtime Enforcement Mechanisms

Runtime enforcement aims at verifying the active execution trace of executing software against formally specified properties of the software, and enforcing the properties in case that they are violated in the active execution trace. Enforcement mechanism of individual properties may interfere with each other, causing the overall behavior of the executing software to be erroneous. As the number and the complexity of the properties to be enforced increase, manual detection of the inferences becomes an error-prone and effort-consuming task. Hence, we aim at providing a framework for automatic detection of interferences. As the initial steps to create such a framework, in this paper we first provide formal definitions of an enforcement mechanism and enforcement operators. Second, we define a rule set to detect the interference among properties

Adopting Architectural Event Modules for Modular Coordination of Multiple Applications

Nowadays, large-scale software systems consist of multiple applications, which interact with each other to fulfill desired system-level requirements. It is usually required to coordinate the interactions of the constituent applications to ensure that the system-level requirements are fulfilled. In this paper, we outline a set of requirements that must be fulfilled to facilitate the modular composition of multiple applications. We introduce the concept of architectural event modules, which are abstractions to represent constituent applications and their coordination logic in a modular and uniform way. We explain the implementation of this concept in the EventReactor language, and define their formal semantics in processing events using the UPPAAL toolset. We illustrate the suitability of architectural event modules in achieving modularity and loose coupling in the composition of multiple applications by means of a case study in the domain of energy-efficient computing

Hermeneutics framework: integration of design rationale and optimizing software modules

To tackle the evolution challenges of adaptive systems, this paper argues on the necessity of hermeneutic approaches that help to avoid too early elimination of design alternatives. This visionary paper proposes the Hermeneutics Framework, which computationally integrates a design rationale management system, an auto-adaptive control system and a reflective and modular event-driven language runtime together. The Hermeneutics Framework is, among others, suitable for implementing dynamic adaptive software systems that undergo intensive evolution cycles

An Overview of Language Support for Modular Event-driven Programming

Nowadays, event processing is becoming the backbone of many applications. Therefore, it is necessary to provide suitable abstractions to properly modularize the concerns that appear in event-driven applications. We identify four categories of languages that support event-driven programming, and identify their shortcomings in achieving modularity in the implementation of applications. We propose gummy modules and their implementation in the GummyJ language as a solution. Gummy modules have well-defined event-based interfaces, and can have a primitive or a composite structure. Composite gummy modules are means to group a set of correlated event processing concerns and restrict the visibility of events among them. We provide an example usage of gummy modules, and discuss their event processing semantics

Event composition model: achieving naturalness in runtime enforcement

Runtime enforcement techniques are introduced in the literature to cope with the failures that occur while software is being executed in its target environment. Runtime enforcement techniques contain various concepts that are composed with each other so that the overall functionality of the techniques is achieved. By the term concept we mean a fundamental abstraction or definition that exists in most runtime enforcement techniques. Since the development of runtime enforcement techniques can be complex, runtime enforcement frameworks are proposed to ease the development process. These frameworks offer specification languages to represent the concepts of interest.\ud To facilitate a natural representation of the concepts, this thesis introduces a computation model termed as Event Composition Model, which offers a set of novel linguistic abstractions, called events, event modules, reactors, reactor chains, event composition language and event constraint language. Events represent changes in the states of interest. Event modules are means to group events, have input-output interfaces, and implementations. Reactors are the implementations of event modules. Reactor chains are groups of related reactors that process events in a sequence. The event composition language facilitates selecting the events of interest; and the event constraint language facilitates defining constraints among reactors or event modules.\ud The thesis introduces the EventReactor language as an implementation of Event Composition Model. The language is open-ended for new sorts of events and reactor types. This helps to specify new sorts of concepts. It makes use of the Prolog language as its event composition language. Reactors and reactor chains are parameterizable, and are defined separately from event modules. This increases the reusability of event modules and their implementations. In the EventReactor language, the concepts of interest are represented independently from any programming language, and the compiler of EventReactor supports software developed in Java, C and .Net languages. For distributed software that makes use of Java-RMI as the middleware, the EventReactor language supports distribution-transparent representations of the concepts.\ud There are two basic ways in utilizing the EventReactor language: a) as an underlying language for the specification languages of runtime enforcement frameworks; b) as an implementation language for runtime enforcement techniques.\u

Specification of the GummyModule Language

The GummyModule language is an extension to the Java language and is the successor of the EventReactor language The GummyModule language adopts the linguistic constructs of offered by EventReactor to define event types, events and to publish events. As for EventReactor, GummyModule facilitates defining the functionality of modules via domain-specific languages (DSL), and is open-ended with new DSLs. This technical report first explains the syntax of the GummyModule language. Afterwards, it discusses the algorithm adopted by the runtime environment of the GummyModule language to process events

A design method for modular energy-aware software

Nowadays achieving green software by reducing the overall energy consumption of the software is becoming more and more important. A well-known solution is to make the software energy-aware by extending its functionality with energy optimizers, which monitor the energy consumption of software and adapt it accordingly. Modular design of energy-aware software is necessary to make the extensions manageable and to cope with the complexity of the software. To this aim, we require suitable methods that guide designers through the necessary design activities and the models that must be prepared during each activity. Despite its importance, such a method is not investigated in the literature. This paper proposes a dedicated design method for energy-aware software, discusses a concrete realization of this method, and—by means of a concrete example—illustrates the suitability of this method in achieving modularity